"""K8s资源文件管理器模块"""

import os
import shutil
from typing import List, Optional, Tuple
import logging
import glob

class FileManager:
    """
    K8s资源文件管理器
    负责处理文件和目录操作，包括创建目录结构、清理输出目录等
    """
    
    def __init__(self, source_dir: str, output_dir: str, config_manager=None, logger: Optional[logging.Logger] = None):
        """
        初始化文件管理器
        
        Args:
            source_dir: 源文件目录
            output_dir: 输出文件目录
            config_manager: 配置管理器，可选
            logger: 日志记录器，可选
        """
        self.source_dir = os.path.abspath(source_dir)
        self.output_dir = os.path.abspath(output_dir)
        self.config_manager = config_manager
        self.logger = logger or logging.getLogger(__name__)
        
        # 从配置中获取选项
        self.recursive = True
        self.preserve_directory_structure = True
        self.file_extensions = ['.yaml', '.yml', '.json']
        
        if self.config_manager:
            self.recursive = self.config_manager.get('extraction', 'recursive', default=True)
            self.preserve_directory_structure = self.config_manager.get('extraction', 'preserve_directory_structure', default=True)
            self.file_extensions = self.config_manager.get('extraction', 'file_extensions', default=['.yaml', '.yml', '.json'])
    
    def prepare_output_directory(self) -> None:
        """
        准备输出目录，清空并重新创建
        """
        self._clean_output_directory()
        self._create_output_directory()
    
    def _clean_output_directory(self) -> None:
        """
        清空输出目录
        """
        if os.path.exists(self.output_dir):
            self.logger.info(f"清空输出目录: {self.output_dir}")
            try:
                shutil.rmtree(self.output_dir)
            except Exception as e:
                self.logger.error(f"清空输出目录失败: {str(e)}")
                raise
    
    def _create_output_directory(self) -> None:
        """
        创建输出目录及其所需的子目录结构
        """
        try:
            os.makedirs(self.output_dir, exist_ok=True)
            self.logger.info(f"创建输出目录: {self.output_dir}")
        except Exception as e:
            self.logger.error(f"创建输出目录失败: {str(e)}")
            raise
    
    def create_directory_structure(self, relative_path: str) -> str:
        """
        在输出目录中创建对应的目录结构
        
        Args:
            relative_path: 相对于源目录的路径
            
        Returns:
            创建的目录完整路径
        """
        directory = os.path.join(self.output_dir, relative_path)
        try:
            os.makedirs(directory, exist_ok=True)
            self.logger.debug(f"创建目录结构: {directory}")
            return directory
        except Exception as e:
            self.logger.error(f"创建目录结构失败: {str(e)}")
            raise
    
    def get_output_path(self, source_file: str, resource_type: str) -> str:
        """
        根据源文件路径和资源类型生成输出文件路径
        
        Args:
            source_file: 源文件路径
            resource_type: 资源类型
            
        Returns:
            输出文件路径
        """
        if self.preserve_directory_structure:
            # 获取相对路径
            rel_path = os.path.relpath(source_file, self.source_dir)
            # 获取目录和文件名
            dir_name = os.path.dirname(rel_path)
            file_name = os.path.basename(rel_path)
            # 以资源类型为前缀的输出文件名
            base_name, _ = os.path.splitext(file_name)
            output_file_name = f"{resource_type}-{base_name}.md"
            # 确保目录存在
            output_dir = os.path.join(self.output_dir, dir_name)
            os.makedirs(output_dir, exist_ok=True)
            # 返回完整输出路径
            return os.path.join(output_dir, output_file_name)
        else:
            # 不保留目录结构，所有文件放在输出根目录
            file_name = os.path.basename(source_file)
            base_name, _ = os.path.splitext(file_name)
            output_file_name = f"{resource_type}-{base_name}.md"
            return os.path.join(self.output_dir, output_file_name)
    
    def find_yaml_files(self) -> List[str]:
        """
        查找源目录下所有YAML和JSON文件
        
        Returns:
            YAML和JSON文件路径列表
        """
        all_files = []
        
        # 根据配置的文件扩展名查找文件
        for ext in self.file_extensions:
            # 确保扩展名以点开头
            if not ext.startswith('.'):
                ext = '.' + ext
            
            # 根据是否递归处理子目录使用不同的查找模式
            if self.recursive:
                pattern = os.path.join(self.source_dir, "**", f"*{ext}")
                files = glob.glob(pattern, recursive=True)
            else:
                pattern = os.path.join(self.source_dir, f"*{ext}")
                files = glob.glob(pattern, recursive=False)
            
            all_files.extend(files)
        
        self.logger.info(f"共发现 {len(all_files)} 个K8s配置文件")
        return all_files
    
    def get_relative_path(self, file_path: str) -> str:
        """
        获取文件相对于源目录的路径
        
        Args:
            file_path: 文件完整路径
            
        Returns:
            相对路径
        """
        return os.path.relpath(file_path, self.source_dir)
    
    def write_markdown_file(self, output_path: str, content: str) -> None:
        """
        写入Markdown文件
        
        Args:
            output_path: 输出文件路径
            content: 文件内容
        """
        try:
            # 确保输出目录存在
            os.makedirs(os.path.dirname(output_path), exist_ok=True)
            
            with open(output_path, 'w', encoding='utf-8') as f:
                f.write(content)
            self.logger.info(f"生成Markdown文件: {output_path}")
        except Exception as e:
            self.logger.error(f"写入Markdown文件失败: {output_path}, 原因: {str(e)}")
            raise